/**
 * 名字结果页面
 * 显示根据用户输入条件生成的名字列表及详情
 */

// 导入工具模块
const ApiService = require('../../utils/api.js');
const NameMessages = require('../../utils/nameGenerationMessages.js');

// 名字处理器工厂 - 根据不同取名方法创建相应的处理器
const NameProcessorFactory = {
  // 创建名字处理器
  create(methodType) {
    switch (methodType) {
      case 'bazi': return new BaziNameProcessor();
      case 'culture': return new CultureNameProcessor();
      case 'combined': return new CombinedNameProcessor();
      case 'zodiac': return new ZodiacNameProcessor();
      default: return new DefaultNameProcessor();
    }
  }
};

// 基础名字处理器
class BaseNameProcessor {
  constructor() {}
  
  // 处理通用名字属性
  processBasicInfo(item, surname) {
    const fullName = item.name.startsWith(surname) ? item.name : surname + item.name;
    return {
      fullName,
      pinyin: item.pinyin || '',
      totalScore: item.scoring?.total_score || item.score || 0,
      isFavorite: false
    };
  }
  
  // 提取字形结构信息
  processStructure(item) {
    return {
      structureScore: item.scoring?.character_structure?.score || 0,
      structureComment: item.scoring?.character_structure?.comment || '',
    };
  }
  
  // 提取音韵效果信息
  processPhonology(item) {
    return {
      phonologyScore: item.scoring?.phonology?.score || 0,
      phonologyComment: item.scoring?.phonology?.comment || '',
    };
  }
  
  // 提取性别适配信息
  processGenderFit(item) {
    return {
      genderFit: item.scoring?.gender_fit?.comment || '',
      genderScore: item.scoring?.gender_fit?.score || 0,
    };
  }
  
  // 提取寓意信息
  processMeaning(item) {
    return {
      meaning: item.scoring?.meaning?.comment || '',
      meaningScore: item.scoring?.meaning?.score || 0,
    };
  }
  
  // 提取笔画信息
  extractStrokes(item) {
    if (!item) return '';
    
    // 尝试多种可能的位置获取笔画信息
    if (item.strokes) {
      return item.strokes;
    }
    
    if (item.scoring && item.scoring.character_structure) {
      const structure = item.scoring.character_structure;
      
      if (structure.strokes) {
        return structure.strokes;
      }
      
      if (structure.comment) {
        const match = structure.comment.match(/(\d+)\+(\d+)画/);
        if (match) {
          return `${match[1]}+${match[2]}`;
        }
      }
    }
    
    return '';
  }
}

// 八字五行法名字处理器
class BaziNameProcessor extends BaseNameProcessor {
  process(passNames, surname) {
    return passNames.map(item => {
      try {
        return {
          ...this.processBasicInfo(item, surname),
          ...this.processPhonology(item),
          ...this.processStructure(item),
          ...this.processMeaning(item),
          wuxing: item.scoring?.five_elements?.match || '',
          strokes: this.extractStrokes(item),
          matchScore: item.scoring?.five_elements?.score || 0,
          requirement: item.scoring?.five_elements?.requirement || '',
          match: item.scoring?.five_elements?.match || '',
          fiveElementsComment: item.scoring?.five_elements?.comment || '',
          rareChar: item.scoring?.character_structure?.rare_char || 'n',
          complexChar: item.scoring?.character_structure?.complex_char || 'n',
          genderPenalty: item.scoring?.gender_deduction?.penalty || 0,
          genderFit: item.scoring?.gender_deduction?.comment || '',
        };
      } catch (e) {
        console.error('处理八字名字项目出错:', e);
        return this.createErrorNameObject();
      }
    });
  }
  
  createErrorNameObject() {
    return {
      fullName: '处理错误',
      pinyin: '',
      totalScore: 0,
      isFavorite: false
    };
  }
}

// 文化典故法名字处理器
class CultureNameProcessor extends BaseNameProcessor {
  process(passNames, surname) {
    return passNames.map(item => {
      try {
        return {
          ...this.processBasicInfo(item, surname),
          ...this.processPhonology(item),
          ...this.processStructure(item),
          ...this.processMeaning(item),
          ...this.processGenderFit(item),
          // 文化内涵相关评分
          allusion: item.scoring?.literary_source?.allusion || '',
          source: item.scoring?.literary_source?.source || '',
          expectationMatch: item.scoring?.literary_source?.expectation_match || '',
          literaryComment: item.scoring?.literary_source?.comment || '',
          literaryScore: item.scoring?.literary_source?.score || 0,
        };
      } catch (e) {
        console.error('处理文化典故名字项目出错:', e);
        return this.createErrorNameObject();
      }
    });
  }
  
  createErrorNameObject() {
    return {
      fullName: '处理错误',
      pinyin: '',
      totalScore: 0,
      isFavorite: false
    };
  }
}

// 五行典故结合法名字处理器
class CombinedNameProcessor extends BaseNameProcessor {
  process(passNames, surname) {
    return passNames.map(item => {
      try {
        return {
          ...this.processBasicInfo(item, surname),
          ...this.processPhonology(item),
          ...this.processStructure(item),
          ...this.processGenderFit(item),
          // 文化内涵相关评分
          allusion: item.scoring?.cultural_connotation?.allusion || '',
          source: item.scoring?.cultural_connotation?.author || '',
          literaryComment: item.scoring?.cultural_connotation?.comment || '',
          literaryScore: item.scoring?.cultural_connotation?.score || 0,
          // 五行因素
          wuxing: item.wuxing || '',
          wuxingScore: item.scoring?.five_elements?.score || 0,
          wuxingComment: item.scoring?.five_elements?.comment || '',
        };
      } catch (e) {
        console.error('处理五行典故结合名字项目出错:', e);
        return this.createErrorNameObject();
      }
    });
  }
  
  createErrorNameObject() {
    return {
      fullName: '处理错误',
      pinyin: '',
      totalScore: 0,
      isFavorite: false
    };
  }
}

// 生肖取名法名字处理器
class ZodiacNameProcessor extends BaseNameProcessor {
  process(passNames, surname) {
    return passNames.map(item => {
      try {
        return {
          ...this.processBasicInfo(item, surname),
          ...this.processPhonology(item),
          ...this.processStructure(item),
          ...this.processMeaning(item),
          ...this.processGenderFit(item),
          // 生肖相关评分
          zodiacComment: item.scoring?.zodiac_fit?.comment || '',
          recommendedWords: item.scoring?.zodiac_fit?.recommended_words || '',
          avoidance: item.scoring?.zodiac_fit?.avoidance || '',
          zodiacScore: item.scoring?.zodiac_fit?.score || 0,
        };
      } catch (e) {
        console.error('处理生肖取名法名字项目出错:', e);
        return this.createErrorNameObject();
      }
    });
  }
  
  createErrorNameObject() {
    return {
      fullName: '处理错误',
      pinyin: '',
      totalScore: 0,
      isFavorite: false
    };
  }
}

// 默认名字处理器
class DefaultNameProcessor extends BaseNameProcessor {
  process(passNames, surname) {
    return passNames.map(item => {
      try {
        const fullName = item.name.startsWith(surname) ? item.name : 
                        (item.name ? (surname + item.name) : '未知');
        
        return {
          fullName,
          pinyin: item.pinyin || '',
          meaning: item.meaning || '',
          totalScore: item.score || 0,
          isFavorite: false
        };
      } catch (e) {
        console.error('处理默认名字项目出错:', e);
        return {
          fullName: '处理错误',
          pinyin: '',
          totalScore: 0,
          isFavorite: false
        };
      }
    });
  }
}

// 数据管理器
class DataManager {
  // 从各种来源获取数据
  static async getInitialData(options, page) {
    // 从URL参数获取数据
    if (options && options.hasData === 'true') {
      // 尝试从全局变量获取数据
      const app = getApp();
      if (app.globalData && app.globalData.namesResult) {
        const data = app.globalData.namesResult;
        return {
          resultData: data,
          methodType: data.methodType || options.methodType || 'bazi',
          namesData: data.namesData
        };
      }
      
      // 从本地存储获取数据
      const storedData = wx.getStorageSync('namesResultData');
      if (storedData) {
        return {
          resultData: storedData,
          methodType: storedData.methodType || options.methodType || 'bazi',
          namesData: storedData.namesData
        };
      }
    }
    
    // 从事件通道获取数据
    const eventChannel = page.getOpenerEventChannel();
    if (!eventChannel || !eventChannel.on) {
      if (options && options.methodType) {
        return {
          methodType: options.methodType
        };
      }
      throw new Error('无法获取事件通道');
    }
    
    return new Promise((resolve, reject) => {
      eventChannel.on('resultData', (data) => {
        resolve({
          resultData: data,
          methodType: data.methodType || 'bazi',
          namesData: data.namesData
        });
      });
      
      eventChannel.on('error', (error) => {
        reject(error);
      });
    });
  }
  
  // 拼装API请求参数
  static prepareRequestParams(data, existingNames = []) {
    // 创建基础请求参数
    const requestData = {
      ...data,
      surname: data.surname || '',
      gender: data.gender || 'male',
      nameLength: data.nameLength || '2',
      preference: data.methodType || 'zodiac',
      is_rare_character: data.disableRareChars ? "y" : "n",
      is_complex_character: data.disableComplexChars ? "y" : "n",
      zodiac: data.selectedZodiac || data.zodiac || '',
      is_fixedname: data.is_fixedname || false,
      fixedposition: data.fixedposition || 'first',
      fixed_word: data.fixed_word || '',
      unuse_name: existingNames.join(',')
    };
    
    // 根据不同取名方法添加特定参数
    switch (data.methodType) {
      case 'culture':
        const traits = data.traits || [];
        const expectation = data.expectation || '';
        const traitsStr = traits.join('、');
        requestData.optimize_expect = traitsStr + (traitsStr && expectation ? '，' : '') + expectation;
        break;
      case 'combined':
        requestData.optimize_expect = data.expectation || '';
        requestData.wuxing = data.wuxing || '';
        break;
      case 'bazi':
        requestData.wuxing = data.wuxing || '';
        break;
    }
    
    return requestData;
  }
  
  // 解析API返回的数据
  static parseApiResponse(apiResponse) {
    // 处理接口返回的复杂JSON结构
    if (apiResponse && apiResponse.code === 0 && apiResponse.data) {
      try {
        return JSON.parse(apiResponse.data);
      } catch (e) {
        // 尝试处理不完整的JSON字符串
        try {
          const match = apiResponse.data.match(/\"passNames\":\s*\"([\s\S]*?)\"/);
          if (match && match[1]) {
            let passNamesStr = match[1]
              .replace(/\\"/g, '"')
              .replace(/\\n/g, '')
              .replace(/\\\\/g, '\\');
            
            if (passNamesStr.trim().startsWith('[') && !passNamesStr.trim().endsWith(']')) {
              passNamesStr += ']';
            }
            
            const parsedNames = JSON.parse(passNamesStr);
            return { passNames: parsedNames };
          }
        } catch (extractErr) {
          console.error('尝试提取passNames失败:', extractErr);
          throw new Error('无法解析API返回的数据');
        }
      }
    }
    
    if (!apiResponse || !apiResponse.passNames) {
      throw new Error('API响应数据格式错误');
    }
    
    return apiResponse;
  }
  
  // 处理可能是字符串的passNames
  static ensurePassNamesArray(passNames) {
    if (typeof passNames === 'string') {
      try {
        // 标准化字符串
        let cleanPassNames = passNames
          .replace(/\\n/g, '')
          .replace(/\\\\/g, '\\')
          .replace(/\\"/g, '"')
          .trim();
        
        // 确保是合法的JSON数组格式
        if (!cleanPassNames.startsWith('[')) cleanPassNames = '[' + cleanPassNames;
        if (!cleanPassNames.endsWith(']')) cleanPassNames = cleanPassNames + ']';
        
        try {
          return JSON.parse(cleanPassNames);
        } catch (firstErr) {
          // 尝试其他修复方法
          const validContent = cleanPassNames.match(/\[[\s\S]*\]/);
          if (validContent) {
            return JSON.parse(validContent[0]);
          }
          
          // 最后尝试
          return JSON.parse('[' + cleanPassNames.split('[')[1].split(']')[0] + ']');
        }
      } catch (e) {
        console.error('解析passNames字符串失败:', e);
        return [];
      }
    }
    
    // 已经是数组则直接返回
    return passNames;
  }
}

// UI管理器
class UIManager {
  // 创建循环提示
  static createRotatingToast(messages, page) {
    let messageIndex = 0;
    
    const showMessage = () => {
      try {
        wx.hideToast();
        wx.hideLoading();
      } catch (e) {
        console.error('隐藏提示出错:', e);
      }
      
      wx.showToast({
        title: messages[messageIndex],
        icon: 'none',
        duration: 10000,
        mask: true
      });
      
      messageIndex = (messageIndex + 1) % messages.length;
    };
    
    // 首次显示延迟
    const firstTimer = setTimeout(() => {
      if (page.data.isLoading) {
        showMessage();
      }
    }, 3000);
    
    // 循环显示
    const interval = setInterval(() => {
      if (page.data.isLoading) {
        showMessage();
      } else {
        clearInterval(interval);
      }
    }, 4000);
    
    return {
      firstTimer,
      interval,
      clear: () => {
        clearTimeout(firstTimer);
        clearInterval(interval);
      }
    };
  }
  
  // 创建分享标题
  static createShareTitle(name, methodType, zodiac = '') {
    switch (methodType) {
      case 'bazi':
        return `我用八字五行法为宝宝起名：${name}，五行平衡，你觉得如何？`;
      case 'culture':
        return `我用文化典故法为宝宝起名：${name}，寓意深远，你喜欢吗？`;
      case 'combined':
        return `我用五行典故结合法为宝宝起名：${name}，命理文化双重加持！`;
      case 'zodiac':
        return `我用生肖${zodiac}取名法为宝宝起名：${name}，你觉得合适吗？`;
      default:
        return `我为宝宝选的名字：${name}，你觉得怎么样？`;
    }
  }
  
  // 创建朋友圈分享标题
  static createTimelineTitle(name, methodType, zodiac = '') {
    switch (methodType) {
      case 'bazi':
        return `八字五行法取名，推荐这个五行平衡的好名字：${name}`;
      case 'culture':
        return `文化典故法取名，推荐这个寓意深远的好名字：${name}`;
      case 'combined':
        return `五行典故结合法取名，推荐这个命理文化双全的好名字：${name}`;
      case 'zodiac':
        return `生肖${zodiac}取名法，推荐这个吉祥如意的好名字：${name}`;
      default:
        return `给新生宝宝起名，推荐这个好名字：${name}`;
    }
  }
  
  // 查找最高分的名字
  static findBestName(names, defaultName = "智能取名") {
    if (!names || names.length === 0) return defaultName;
    
    let bestName = defaultName;
    let highestScore = 0;
    
    names.forEach(item => {
      if (item.totalScore > highestScore) {
        highestScore = item.totalScore;
        bestName = item.fullName;
      }
    });
    
    return bestName;
  }
}

// 结果页面逻辑
Page({
  data: {
    names: [],                  // 名字列表
    resultData: null,           // 结果数据
    methodType: '',             // 取名方法类型：bazi, culture, combined, zodiac
    isLoading: false,           // 加载状态
    showDetailIndex: -1,        // 当前展开详情的索引，-1表示没有展开任何详情
    currentShareIndex: -1,      // 当前分享的名字索引
    adCompleted: false,         // 广告是否播放完成
    apiCompleted: false,        // API是否已完成
    apiResult: null,            // API返回结果
    messageTimers: {            // 消息定时器
      firstTimer: null,
      interval: null
    }
  },

  // 页面加载
  async onLoad(options) {
    this.setData({ isLoading: true });
    
    // 安全超时处理
    const safetyTimer = setTimeout(() => {
      this.resetLoadingState('加载超时，请重试');
    }, 95000);
    
    try {
      // 获取初始数据
      const data = await DataManager.getInitialData(options, this);
      
      // 更新页面数据
      this.setData({
        resultData: data.resultData,
        methodType: data.methodType
      });
      
      // 如果有名字数据，直接处理
      if (data.namesData) {
        this.processApiResponse(data.namesData);
        this.resetLoadingState();
        clearTimeout(safetyTimer);
      } else if (data.resultData) {
        // 否则调用API生成名字
        try {
          await this.generateNames(data.resultData);
        } finally {
          this.resetLoadingState();
          clearTimeout(safetyTimer);
        }
      } else {
        this.resetLoadingState();
        clearTimeout(safetyTimer);
      }
    } catch (error) {
      console.error('页面加载错误:', error);
      this.resetLoadingState('数据加载错误，请重试');
      clearTimeout(safetyTimer);
    }
    
    // 创建激励广告实例
    this.createRewardedVideoAd();
  },

  // 创建激励广告实例
  createRewardedVideoAd() {
    if (wx.createRewardedVideoAd) {
      this.rewardedVideoAd = wx.createRewardedVideoAd({
        adUnitId: 'adunit-9e4cf424d63967f5'
      });

      // 监听广告加载事件
      this.rewardedVideoAd.onLoad(() => {
        console.log('激励广告加载成功');
      });

      // 监听广告错误事件
      this.rewardedVideoAd.onError((err) => {
        console.error('激励广告出错:', err);
        // 广告拉取异常视为播放完毕
        this.setData({
          adCompleted: true
        });
        
        // 如果API已完成，立即停止提示消息
        if (this.data.apiCompleted) {
          this.showMessages(false);
        }
        
        // 检查是否可以渲染数据
        this.checkRenderConditions();
      });

      // 监听广告关闭事件
      this.rewardedVideoAd.onClose((res) => {
        console.log('激励广告关闭', res);
        
        // 判断是否是正常关闭(用户看完了广告)
        if (res && res.isEnded) {
          console.log('激励广告完整观看');
          this.setData({
            adCompleted: true
          });
          
          // 如果API已完成，立即停止提示消息
          if (this.data.apiCompleted) {
            this.showMessages(false);
          }
          
          // 检查是否可以渲染数据
          this.checkRenderConditions();
        } else {
          // 不是正常结束时先停止消息循环
          this.showMessages(false);
          
          console.log('激励广告提前关闭');
          // 提示用户广告未播放完毕
          wx.showModal({
            title: '提示',
            content: '广告未播放完毕，无法生成名字，是否继续播放？',
            success: (res) => {
              if (res.confirm) {
                // 用户点击确定，继续播放广告
                this.showMessages(true); // 重新打开提示消息
                this.showRewardedVideoAd(); // 重新播放广告
              } else {
                // 用户点击取消，中断名字生成流程
                this.cancelMoreNameGeneration();
              }
            }
          });
        }
      });
    }
  },

  // 显示激励广告
  showRewardedVideoAd() {
    if (this.rewardedVideoAd) {
      this.rewardedVideoAd.show()
        .catch(err => {
          // 失败重试
          this.rewardedVideoAd.load()
            .then(() => this.rewardedVideoAd.show())
            .catch(err => {
              console.error('激励广告显示失败:', err);
              // 广告显示异常视为播放完毕
              this.setData({
                adCompleted: true
              });
              
              // 如果API已完成，立即停止提示消息
              if (this.data.apiCompleted) {
                this.showMessages(false);
              }
              
              // 检查是否可以渲染数据
              this.checkRenderConditions();
            });
        });
    }
  },

  // 取消更多名字生成
  cancelMoreNameGeneration() {
    // 重置状态
    this.setData({
      isLoading: false,
      adCompleted: false,
      apiCompleted: false,
      apiResult: null
    });
    
    // 关闭所有提示
    this.showMessages(false);
    
    try {
      wx.hideToast();
    } catch (e) {
      console.error('hideToast error:', e);
    }
    
    try {
      wx.hideLoading();
    } catch (e) {
      console.error('hideLoading error:', e);
    }
  },

  // 检查是否满足渲染条件
  checkRenderConditions() {
    if (this.data.adCompleted && this.data.apiCompleted && this.data.apiResult) {
      // 确保消息循环已关闭
      this.showMessages(false);
      // 处理API响应，渲染新名字
      this.processApiResponse(this.data.apiResult, true);
      // 重置状态
      this.setData({
        isLoading: false,
        adCompleted: false,
        apiCompleted: false,
        apiResult: null
      });
    }
  },

  // 循环显示提示消息
  showMessages(isShow) {
    // 清除可能存在的旧定时器
    if (this.data.messageTimers.firstTimer) {
      clearTimeout(this.data.messageTimers.firstTimer);
    }
    
    if (this.data.messageTimers.interval) {
      clearInterval(this.data.messageTimers.interval);
    }
    
    if (!isShow) {
      // 如果不需要显示消息，直接返回
      return;
    }
    
    // 根据不同取名方法获取对应的提示消息
    const nameGenerationMessages = NameMessages.getMessagesByPreference(this.data.methodType);
    let nameMessageIndex = 0;
    
    const showNameGenerationMessage = () => {
      // 先隐藏之前的提示
      try {
        wx.hideToast();
      } catch (e) {
        console.error('hideToast error:', e);
      }
      
      try {
        wx.hideLoading();
      } catch (e) {
        console.error('hideLoading error:', e);
      }
      
      // 显示新的提示 - 设置mask为false，让用户可以点击其他元素
      wx.showToast({
        title: nameGenerationMessages[nameMessageIndex],
        icon: 'none',
        duration: 10000,
        mask: false
      });
      
      // 更新消息索引，循环使用提示
      nameMessageIndex = (nameMessageIndex + 1) % nameGenerationMessages.length;
    };
    
    // 3秒后显示第一次提示
    const firstNameTimer = setTimeout(() => {
      if (this.data.isLoading) {
        showNameGenerationMessage();
      }
    }, 3000);
    
    // 每4秒更新一次提示，直到请求完成
    const nameGenerationInterval = setInterval(() => {
      if (this.data.isLoading) {
        showNameGenerationMessage();
      } else {
        clearInterval(nameGenerationInterval);
      }
    }, 4000);
    
    // 保存定时器引用
    this.setData({
      messageTimers: {
        firstTimer: firstNameTimer,
        interval: nameGenerationInterval
      }
    });
  },

  // 重置加载状态
  resetLoadingState(errorMessage = '') {
    this.setData({ isLoading: false });
    wx.hideLoading();
    
    if (errorMessage && this.data.names.length === 0) {
      wx.showToast({
        title: errorMessage,
        icon: 'none',
        duration: 2000
      });
    }
  },

  // 切换名字详情的显示状态
  toggleDetail(e) {
    const index = e.currentTarget.dataset.index;
    
    this.setData({ 
      showDetailIndex: index === this.data.showDetailIndex ? -1 : index 
    });
  },

  // 关闭详情
  closeDetail() {
    this.setData({ showDetailIndex: -1 });
  },

  // 生成更多名字
  generateMore() {
    // 提示用户将播放广告
    wx.showModal({
      title: '提示',
      content: '计算名字大概需要30秒，为了分担服务成本，会播放一段广告，请耐心等待...',
      success: (res) => {
        if (res.confirm) {
          // 用户同意观看广告，开始生成更多名字流程
          this.startMoreNameGeneration();
        } else {
          // 用户拒绝观看广告，中断流程
          console.log('用户拒绝观看广告');
        }
      }
    });
  },

  // 开始生成更多名字流程
  startMoreNameGeneration() {
    // 获取当前已生成的名字列表
    const existingNames = this.data.names.map(name => name.fullName);
    
    // 准备API请求参数
    const requestData = DataManager.prepareRequestParams(
      this.data.resultData, 
      existingNames
    );
    
    // 重置状态
    this.setData({
      isLoading: true,
      adCompleted: false,
      apiCompleted: false,
      apiResult: null
    });

    // 显示初始加载动画 - 确保mask为false允许点击
    wx.showLoading({
      title: '正在生成更多名字\n请耐心等待...',
      mask: false
    });
    
    // 启动提示消息循环显示
    this.showMessages(true);
    
    // 异步调用API生成更多名字
    this.callNameGenerationAPI(requestData)
      .then(result => {
        // 保存API结果
        this.setData({
          apiCompleted: true,
          apiResult: result
        });
        
        // 如果广告已完成，立即停止提示消息
        if (this.data.adCompleted) {
          this.showMessages(false);
        }
        
        // 检查是否可以渲染数据
        this.checkRenderConditions();
      })
      .catch(error => {
        console.error('生成更多名字失败:', error);
        this.setData({
          isLoading: false,
          apiCompleted: true
        });
        
        // 无论成功失败都应该停止提示消息
        this.showMessages(false);
        
        wx.showToast({
          title: '生成名字失败，请重试',
          icon: 'none'
        });
      });
 
    // 开始播放激励广告
    this.showRewardedVideoAd();
  },

  // 调用API生成名字
  callNameGenerationAPI(data) {
    // 返回Promise以支持异步流程控制
    return new Promise((resolve, reject) => {
      // 调用API生成名字
      ApiService.generateRealName(data)
        .then(result => {
          console.log('API返回的名字数据:', result);
          resolve(result);
        })
        .catch(error => {
          console.error('生成名字API调用失败:', error);
          reject(error);
        });
    });
  },

  // 调用API生成名字（原有方法改为调用异步方法）
  async generateNames(data, isAppend = false) {
    this.setData({ isLoading: true });
    wx.showLoading({ title: '正在生成名字...' });

    // 安全超时
    const generateTimeout = setTimeout(() => {
      this.resetLoadingState('生成超时，请重试');
    }, 95000);

    // 循环提示消息
    const messages = NameMessages.getMessagesByPreference(data.methodType || 'zodiac');
    const toastManager = UIManager.createRotatingToast(messages, this);

    try {
      // 准备API请求参数
      const apiData = {
        ...data,
        surname: data.surname || ''
      };
      
      // 调用API生成名字
      const result = await this.callNameGenerationAPI(apiData);
      this.processApiResponse(result, isAppend);
    } catch (error) {
      console.error('生成名字错误:', error);
      wx.showToast({
        title: '生成名字失败，请重试',
        icon: 'none'
      });
    } finally {
      clearTimeout(generateTimeout);
      toastManager.clear();
      wx.hideLoading();
      this.setData({ isLoading: false });
    }
  },

  // 处理API响应数据
  processApiResponse(apiResponse, isAppend = false) {
    try {
      // 解析API响应
      const parsedResponse = DataManager.parseApiResponse(apiResponse);
      let passNames = parsedResponse.passNames;
      
      // 确保passNames是数组
      passNames = DataManager.ensurePassNamesArray(passNames);
      
      if (!Array.isArray(passNames)) {
        throw new Error('passNames不是数组');
      }

      // 使用工厂创建对应的名字处理器
      const processor = NameProcessorFactory.create(this.data.methodType);
      const surname = this.data.resultData?.surname || '';
      const namesArray = processor.process(passNames, surname);

      if (namesArray.length === 0) {
        wx.showToast({
          title: '未能生成合适的名字，请调整条件重试',
          icon: 'none',
          duration: 2000
        });
      }
      
      // 更新名字列表
      if (isAppend && this.data.names && this.data.names.length > 0) {
        this.setData({ 
          names: [...this.data.names, ...namesArray],
          isLoading: false
        });
      } else {
        this.setData({ 
          names: namesArray,
          isLoading: false
        });
      }
    } catch (error) {
      console.error('处理API响应时出现错误:', error);
      wx.showToast({
        title: '处理数据时出错，请重试',
        icon: 'none',
        duration: 2000
      });
      
      if (!isAppend) {
        this.setData({ names: [], isLoading: false });
      }
    }
  },

  // 页面卸载时清理资源
  onUnload() {
    // 清理消息定时器
    this.showMessages(false);
    
    // 清理广告相关资源
    if (this.rewardedVideoAd) {
      try {
        // 尝试销毁广告实例，不是所有小程序版本都支持此方法
        if (typeof this.rewardedVideoAd.destroy === 'function') {
          this.rewardedVideoAd.destroy();
        }
      } catch (e) {
        console.error('销毁广告实例失败:', e);
      }
    }
  },

  // 收藏/取消收藏名字
  toggleFavorite(e) {
    const index = e.currentTarget.dataset.index;
    const names = [...this.data.names];
    names[index].isFavorite = !names[index].isFavorite;
    
    this.setData({ names });

    // 保存收藏状态到本地存储
    const favorites = wx.getStorageSync('favorites') || [];
    
    if (names[index].isFavorite) {
      // 添加methodType信息以便在收藏页面进行个性化分享
      const nameWithMethodType = {
        ...names[index],
        methodType: this.data.methodType
      };
      
      // 如果是生肖取名法，还需要保存生肖信息
      if (this.data.methodType === 'zodiac' && 
          this.data.resultData && 
          this.data.resultData.selectedZodiac) {
        nameWithMethodType.selectedZodiac = this.data.resultData.selectedZodiac;
      }
      
      favorites.push(nameWithMethodType);
      wx.showToast({ title: '收藏成功', icon: 'success', duration: 1500 });
    } else {
      const favoriteIndex = favorites.findIndex(item => item.fullName === names[index].fullName);
      if (favoriteIndex > -1) {
        favorites.splice(favoriteIndex, 1);
      }
      wx.showToast({ title: '已取消收藏', icon: 'success', duration: 1500 });
    }
    
    wx.setStorageSync('favorites', favorites);
  },

  // 分享名字
  shareName(e) {
    const index = e.currentTarget.dataset.index;
    this.setData({ currentShareIndex: index });
    // open-type="share"按钮会自动触发微信的分享面板
  },

  // 重试生成名字
  retryGenerate() {
    wx.navigateBack();
  },

  // 查看收藏夹
  viewFavorites() {
    // 在导航前检查登录状态
    const app = getApp();
    
    app.checkSession()
      .then(() => {
        // 登录状态有效，导航到收藏页面
        wx.navigateTo({
          url: '/pages/favorites/favorites',
          fail: (err) => {
            this.handleNavigationError(err, app);
          }
        });
      })
      .catch(err => {
        console.error('检查登录状态失败:', err);
        wx.showToast({
          title: '登录状态检查失败，请重试',
          icon: 'none'
        });
      });
  },
  
  // 处理导航错误
  handleNavigationError(err, app) {
    console.error('导航到收藏页面失败:', err);
    
    if (err.errMsg && err.errMsg.includes('需要重新登录')) {
      wx.showToast({
        title: '登录状态已过期，正在尝试重新登录',
        icon: 'none',
        duration: 2000
      });
      
      // 尝试重新登录
      setTimeout(() => {
        app.login();
        
        // 延迟后再次尝试导航
        setTimeout(() => {
          wx.navigateTo({
            url: '/pages/favorites/favorites',
            fail: (e) => {
              console.error('第二次尝试导航失败:', e);
              wx.showToast({
                title: '无法打开收藏页面，请重试',
                icon: 'none'
              });
            }
          });
        }, 1500);
      }, 500);
    } else {
      wx.showToast({
        title: '无法打开收藏页面',
        icon: 'none'
      });
    }
  },

  /**
   * 用户点击右上角分享到好友（发送给朋友）
   */
  onShareAppMessage(res) {
    const methodType = this.data.methodType;
    const zodiac = this.data.resultData?.selectedZodiac || '';
    let shareName;
    
    // 如果是从分享按钮触发
    if (res.from === 'button') {
      // 获取要分享的名字
      const index = this.data.currentShareIndex !== -1 ? 
        this.data.currentShareIndex : 
        (res.target?.dataset?.index || 0);
        
      if (index !== undefined && this.data.names?.[index]) {
        shareName = this.data.names[index].fullName;
        
        return {
          title: UIManager.createShareTitle(shareName, methodType, zodiac),
          path: '/pages/index/index'
        };
      }
    }
    
    // 右上角菜单分享，使用最高分的名字
    shareName = UIManager.findBestName(this.data.names, "游心起名");
    
    return {
      title: UIManager.createTimelineTitle(shareName, methodType, zodiac),
      path: '/pages/index/index'
    };
  },
  
  /**
   * 用户点击右上角分享到朋友圈
   */
  onShareTimeline() {
    const methodType = this.data.methodType;
    const zodiac = this.data.resultData?.selectedZodiac || '';
    let shareName;
    
    // 如果有当前选择的名字索引，优先使用它
    if (this.data.currentShareIndex !== -1 && 
        this.data.names?.[this.data.currentShareIndex]) {
      shareName = this.data.names[this.data.currentShareIndex].fullName;
    } else {
      // 否则使用最高分的名字
      shareName = UIManager.findBestName(this.data.names);
    }
    
    return {
      title: UIManager.createTimelineTitle(shareName, methodType, zodiac),
      query: ''
    };
  }
});